// Copyright (c) Appeon. All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. 
// You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.


// Generated from CommonParser.g4 by ANTLR 4.7.2

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591
// Ambiguous reference in cref attribute
#pragma warning disable 419

namespace Common.Grammar.Antlr
{
    using System;
    using System.IO;
    using Antlr4.Runtime;
    using Antlr4.Runtime.Atn;
    using Antlr4.Runtime.Misc;
    using Antlr4.Runtime.Tree;
    using DFA = Antlr4.Runtime.Dfa.DFA;

    [System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")]
    [System.CLSCompliant(false)]
#pragma warning disable CS3021 // Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
    public partial class CommonParser : Parser
    {
#pragma warning restore CS3021 // Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
        protected static DFA[] decisionToDFA;
        protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
        public const int
            TOKEN_OP_LPARENT = 1, TOKEN_OP_RPARENT = 2, TOKEN_OP_LBRACE = 3, TOKEN_OP_RBRACE = 4,
            TOKEN_OP_EQUALEQUAL = 5, TOKEN_OP_BANGEQ = 6, TOKEN_OP_GE = 7, TOKEN_OP_LE = 8,
            TOKEN_OP_OR = 9, TOKEN_OP_AND = 10, TOKEN_OP_PLUS = 11, TOKEN_OP_DASH = 12, TOKEN_OP_STAR = 13,
            TOKEN_OP_CARET = 14, TOKEN_OP_SLASH = 15, TOKEN_OP_MODULUS = 16, TOKEN_OP_EQUAL = 17,
            TOKEN_OP_GT = 18, TOKEN_OP_LT = 19, TOKEN_OP_QUES = 20, TOKEN_OP_BANG = 21, TOKEN_OP_VERSUS = 22,
            TOKEN_OP_EITHER = 23, TOKEN_OP_COLON = 24, TOKEN_OP_COMMA = 25, TOKEN_KEY_TRUE = 26,
            TOKEN_KEY_FALSE = 27, TOKEN_KEY_NEW = 28, TOKEN_IDENTIFIER = 29, BLANK = 30, SL_COMMENT = 31,
            ML_COMMENT = 32, TOKEN_CONST_STRING = 33, TOKEN_CONST_INTEGER = 34, TOKEN_CONST_FLOAT = 35,
            TOKEN_CONST_DECIMAL = 36, TOKEN_CONST_DOUBLE = 37, TOKEN_CONST_DATE = 38, TOKEN_CONST_TIME = 39;
        public const int
            RULE_expression = 0, RULE_expression_primary = 1, RULE_expression_new = 2,
            RULE_expression_new_props = 3, RULE_expression_assign = 4, RULE_expression_other_function = 5,
            RULE_expression_list = 6, RULE_literal = 7;
        public static readonly string[] ruleNames = {
        "expression", "expression_primary", "expression_new", "expression_new_props",
        "expression_assign", "expression_other_function", "expression_list", "literal"
    };

        private static readonly string[] _LiteralNames = {
        null, "'('", "')'", "'{'", "'}'", "'=='", "'!='", "'>='", "'<='", "'||'",
        "'&&'", "'+'", "'-'", "'*'", "'^'", "'/'", "'%'", "'='", "'>'", "'<'",
        "'?'", "'!'", "'&'", "'|'", "':'", "','"
    };
        private static readonly string[] _SymbolicNames = {
        null, "TOKEN_OP_LPARENT", "TOKEN_OP_RPARENT", "TOKEN_OP_LBRACE", "TOKEN_OP_RBRACE",
        "TOKEN_OP_EQUALEQUAL", "TOKEN_OP_BANGEQ", "TOKEN_OP_GE", "TOKEN_OP_LE",
        "TOKEN_OP_OR", "TOKEN_OP_AND", "TOKEN_OP_PLUS", "TOKEN_OP_DASH", "TOKEN_OP_STAR",
        "TOKEN_OP_CARET", "TOKEN_OP_SLASH", "TOKEN_OP_MODULUS", "TOKEN_OP_EQUAL",
        "TOKEN_OP_GT", "TOKEN_OP_LT", "TOKEN_OP_QUES", "TOKEN_OP_BANG", "TOKEN_OP_VERSUS",
        "TOKEN_OP_EITHER", "TOKEN_OP_COLON", "TOKEN_OP_COMMA", "TOKEN_KEY_TRUE",
        "TOKEN_KEY_FALSE", "TOKEN_KEY_NEW", "TOKEN_IDENTIFIER", "BLANK", "SL_COMMENT",
        "ML_COMMENT", "TOKEN_CONST_STRING", "TOKEN_CONST_INTEGER", "TOKEN_CONST_FLOAT",
        "TOKEN_CONST_DECIMAL", "TOKEN_CONST_DOUBLE", "TOKEN_CONST_DATE", "TOKEN_CONST_TIME"
    };
        public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

        [NotNull]
        public override IVocabulary Vocabulary
        {
            get
            {
                return DefaultVocabulary;
            }
        }

        public override string GrammarFileName { get { return "CommonParser.g4"; } }

        public override string[] RuleNames { get { return ruleNames; } }

        public override string SerializedAtn { get { return new string(_serializedATN); } }

        static CommonParser()
        {
            decisionToDFA = new DFA[_ATN.NumberOfDecisions];
            for (int i = 0; i < _ATN.NumberOfDecisions; i++)
            {
                decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
            }
        }

        public CommonParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

        public CommonParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
        : base(input, output, errorOutput)
        {
            Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
        }

        public partial class ExpressionContext : ParserRuleContext
        {
            public ExpressionContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression; } }

            public ExpressionContext() { }
            public virtual void CopyFrom(ExpressionContext context)
            {
                base.CopyFrom(context);
            }
        }
        public partial class Expression_atomContext : ExpressionContext
        {
            public Expression_primaryContext expression_primary()
            {
                return GetRuleContext<Expression_primaryContext>(0);
            }
            public Expression_atomContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_atom(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_parenthesesContext : ExpressionContext
        {
            public ITerminalNode TOKEN_OP_LPARENT() { return GetToken(CommonParser.TOKEN_OP_LPARENT, 0); }
            public ExpressionContext expression()
            {
                return GetRuleContext<ExpressionContext>(0);
            }
            public ITerminalNode TOKEN_OP_RPARENT() { return GetToken(CommonParser.TOKEN_OP_RPARENT, 0); }
            public Expression_parenthesesContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_parentheses(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_notContext : ExpressionContext
        {
            public ITerminalNode TOKEN_OP_BANG() { return GetToken(CommonParser.TOKEN_OP_BANG, 0); }
            public ExpressionContext expression()
            {
                return GetRuleContext<ExpressionContext>(0);
            }
            public Expression_notContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_not(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class IdentifierContext : ExpressionContext
        {
            public ITerminalNode TOKEN_IDENTIFIER() { return GetToken(CommonParser.TOKEN_IDENTIFIER, 0); }
            public IdentifierContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitIdentifier(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_andorContext : ExpressionContext
        {
            public IToken bop;
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_AND() { return GetToken(CommonParser.TOKEN_OP_AND, 0); }
            public ITerminalNode TOKEN_OP_OR() { return GetToken(CommonParser.TOKEN_OP_OR, 0); }
            public Expression_andorContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_andor(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_relationalContext : ExpressionContext
        {
            public IToken bop;
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_GT() { return GetToken(CommonParser.TOKEN_OP_GT, 0); }
            public ITerminalNode TOKEN_OP_LT() { return GetToken(CommonParser.TOKEN_OP_LT, 0); }
            public ITerminalNode TOKEN_OP_GE() { return GetToken(CommonParser.TOKEN_OP_GE, 0); }
            public ITerminalNode TOKEN_OP_LE() { return GetToken(CommonParser.TOKEN_OP_LE, 0); }
            public ITerminalNode TOKEN_OP_BANGEQ() { return GetToken(CommonParser.TOKEN_OP_BANGEQ, 0); }
            public ITerminalNode TOKEN_OP_VERSUS() { return GetToken(CommonParser.TOKEN_OP_VERSUS, 0); }
            public ITerminalNode TOKEN_OP_EITHER() { return GetToken(CommonParser.TOKEN_OP_EITHER, 0); }
            public ITerminalNode TOKEN_OP_EQUALEQUAL() { return GetToken(CommonParser.TOKEN_OP_EQUALEQUAL, 0); }
            public Expression_relationalContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_relational(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_ternaryContext : ExpressionContext
        {
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_QUES() { return GetToken(CommonParser.TOKEN_OP_QUES, 0); }
            public ITerminalNode TOKEN_OP_COLON() { return GetToken(CommonParser.TOKEN_OP_COLON, 0); }
            public Expression_ternaryContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_ternary(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_multiplicativeContext : ExpressionContext
        {
            public IToken bop;
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_STAR() { return GetToken(CommonParser.TOKEN_OP_STAR, 0); }
            public ITerminalNode TOKEN_OP_SLASH() { return GetToken(CommonParser.TOKEN_OP_SLASH, 0); }
            public ITerminalNode TOKEN_OP_MODULUS() { return GetToken(CommonParser.TOKEN_OP_MODULUS, 0); }
            public Expression_multiplicativeContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_multiplicative(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_unitaryContext : ExpressionContext
        {
            public IToken prefix;
            public ExpressionContext expression()
            {
                return GetRuleContext<ExpressionContext>(0);
            }
            public ITerminalNode TOKEN_OP_PLUS() { return GetToken(CommonParser.TOKEN_OP_PLUS, 0); }
            public ITerminalNode TOKEN_OP_DASH() { return GetToken(CommonParser.TOKEN_OP_DASH, 0); }
            public Expression_unitaryContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_unitary(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_caretContext : ExpressionContext
        {
            public IToken bop;
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_CARET() { return GetToken(CommonParser.TOKEN_OP_CARET, 0); }
            public Expression_caretContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_caret(this);
                else return visitor.VisitChildren(this);
            }
        }
        public partial class Expression_additiveContext : ExpressionContext
        {
            public IToken bop;
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode TOKEN_OP_PLUS() { return GetToken(CommonParser.TOKEN_OP_PLUS, 0); }
            public ITerminalNode TOKEN_OP_DASH() { return GetToken(CommonParser.TOKEN_OP_DASH, 0); }
            public Expression_additiveContext(ExpressionContext context) { CopyFrom(context); }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_additive(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public ExpressionContext expression()
        {
            return expression(0);
        }

        private ExpressionContext expression(int _p)
        {
            ParserRuleContext _parentctx = Context;
            int _parentState = State;
            ExpressionContext _localctx = new ExpressionContext(Context, _parentState);
            ExpressionContext _prevctx = _localctx;
            int _startState = 0;
            EnterRecursionRule(_localctx, 0, RULE_expression, _p);
            int _la;
            try
            {
                int _alt;
                EnterOuterAlt(_localctx, 1);
                {
                    State = 27;
                    ErrorHandler.Sync(this);
                    switch (Interpreter.AdaptivePredict(TokenStream, 0, Context))
                    {
                        case 1:
                        {
                            _localctx = new Expression_atomContext(_localctx);
                            Context = _localctx;
                            _prevctx = _localctx;

                            State = 17; expression_primary();
                        }
                        break;
                        case 2:
                        {
                            _localctx = new Expression_parenthesesContext(_localctx);
                            Context = _localctx;
                            _prevctx = _localctx;
                            State = 18; Match(TOKEN_OP_LPARENT);
                            State = 19; expression(0);
                            State = 20; Match(TOKEN_OP_RPARENT);
                        }
                        break;
                        case 3:
                        {
                            _localctx = new Expression_notContext(_localctx);
                            Context = _localctx;
                            _prevctx = _localctx;
                            State = 22; Match(TOKEN_OP_BANG);
                            State = 23; expression(3);
                        }
                        break;
                        case 4:
                        {
                            _localctx = new Expression_unitaryContext(_localctx);
                            Context = _localctx;
                            _prevctx = _localctx;
                            State = 24;
                            ((Expression_unitaryContext)_localctx).prefix = TokenStream.LT(1);
                            _la = TokenStream.LA(1);
                            if (!(_la == TOKEN_OP_PLUS || _la == TOKEN_OP_DASH))
                            {
                                ((Expression_unitaryContext)_localctx).prefix = ErrorHandler.RecoverInline(this);
                            }
                            else
                            {
                                ErrorHandler.ReportMatch(this);
                                Consume();
                            }
                            State = 25; expression(2);
                        }
                        break;
                        case 5:
                        {
                            _localctx = new IdentifierContext(_localctx);
                            Context = _localctx;
                            _prevctx = _localctx;
                            State = 26; Match(TOKEN_IDENTIFIER);
                        }
                        break;
                    }
                    Context.Stop = TokenStream.LT(-1);
                    State = 52;
                    ErrorHandler.Sync(this);
                    _alt = Interpreter.AdaptivePredict(TokenStream, 2, Context);
                    while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
                    {
                        if (_alt == 1)
                        {
                            if (ParseListeners != null)
                                TriggerExitRuleEvent();
                            _prevctx = _localctx;
                            {
                                State = 50;
                                ErrorHandler.Sync(this);
                                switch (Interpreter.AdaptivePredict(TokenStream, 1, Context))
                                {
                                    case 1:
                                    {
                                        _localctx = new Expression_caretContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 29;
                                        if (!(Precpred(Context, 9))) throw new FailedPredicateException(this, "Precpred(Context, 9)");
                                        State = 30; ((Expression_caretContext)_localctx).bop = Match(TOKEN_OP_CARET);
                                        State = 31; expression(10);
                                    }
                                    break;
                                    case 2:
                                    {
                                        _localctx = new Expression_multiplicativeContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 32;
                                        if (!(Precpred(Context, 8))) throw new FailedPredicateException(this, "Precpred(Context, 8)");
                                        State = 33;
                                        ((Expression_multiplicativeContext)_localctx).bop = TokenStream.LT(1);
                                        _la = TokenStream.LA(1);
                                        if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TOKEN_OP_STAR) | (1L << TOKEN_OP_SLASH) | (1L << TOKEN_OP_MODULUS))) != 0)))
                                        {
                                            ((Expression_multiplicativeContext)_localctx).bop = ErrorHandler.RecoverInline(this);
                                        }
                                        else
                                        {
                                            ErrorHandler.ReportMatch(this);
                                            Consume();
                                        }
                                        State = 34; expression(9);
                                    }
                                    break;
                                    case 3:
                                    {
                                        _localctx = new Expression_additiveContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 35;
                                        if (!(Precpred(Context, 7))) throw new FailedPredicateException(this, "Precpred(Context, 7)");
                                        State = 36;
                                        ((Expression_additiveContext)_localctx).bop = TokenStream.LT(1);
                                        _la = TokenStream.LA(1);
                                        if (!(_la == TOKEN_OP_PLUS || _la == TOKEN_OP_DASH))
                                        {
                                            ((Expression_additiveContext)_localctx).bop = ErrorHandler.RecoverInline(this);
                                        }
                                        else
                                        {
                                            ErrorHandler.ReportMatch(this);
                                            Consume();
                                        }
                                        State = 37; expression(8);
                                    }
                                    break;
                                    case 4:
                                    {
                                        _localctx = new Expression_relationalContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 38;
                                        if (!(Precpred(Context, 6))) throw new FailedPredicateException(this, "Precpred(Context, 6)");
                                        State = 39;
                                        ((Expression_relationalContext)_localctx).bop = TokenStream.LT(1);
                                        _la = TokenStream.LA(1);
                                        if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TOKEN_OP_EQUALEQUAL) | (1L << TOKEN_OP_BANGEQ) | (1L << TOKEN_OP_GE) | (1L << TOKEN_OP_LE) | (1L << TOKEN_OP_GT) | (1L << TOKEN_OP_LT) | (1L << TOKEN_OP_VERSUS) | (1L << TOKEN_OP_EITHER))) != 0)))
                                        {
                                            ((Expression_relationalContext)_localctx).bop = ErrorHandler.RecoverInline(this);
                                        }
                                        else
                                        {
                                            ErrorHandler.ReportMatch(this);
                                            Consume();
                                        }
                                        State = 40; expression(7);
                                    }
                                    break;
                                    case 5:
                                    {
                                        _localctx = new Expression_andorContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 41;
                                        if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)");
                                        State = 42;
                                        ((Expression_andorContext)_localctx).bop = TokenStream.LT(1);
                                        _la = TokenStream.LA(1);
                                        if (!(_la == TOKEN_OP_OR || _la == TOKEN_OP_AND))
                                        {
                                            ((Expression_andorContext)_localctx).bop = ErrorHandler.RecoverInline(this);
                                        }
                                        else
                                        {
                                            ErrorHandler.ReportMatch(this);
                                            Consume();
                                        }
                                        State = 43; expression(6);
                                    }
                                    break;
                                    case 6:
                                    {
                                        _localctx = new Expression_ternaryContext(new ExpressionContext(_parentctx, _parentState));
                                        PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                        State = 44;
                                        if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)");
                                        State = 45; Match(TOKEN_OP_QUES);
                                        State = 46; expression(0);
                                        State = 47; Match(TOKEN_OP_COLON);
                                        State = 48; expression(5);
                                    }
                                    break;
                                }
                            }
                        }
                        State = 54;
                        ErrorHandler.Sync(this);
                        _alt = Interpreter.AdaptivePredict(TokenStream, 2, Context);
                    }
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                UnrollRecursionContexts(_parentctx);
            }
            return _localctx;
        }

        public partial class Expression_primaryContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_OP_LPARENT() { return GetToken(CommonParser.TOKEN_OP_LPARENT, 0); }
            public Expression_primaryContext expression_primary()
            {
                return GetRuleContext<Expression_primaryContext>(0);
            }
            public ITerminalNode TOKEN_OP_RPARENT() { return GetToken(CommonParser.TOKEN_OP_RPARENT, 0); }
            public Expression_newContext expression_new()
            {
                return GetRuleContext<Expression_newContext>(0);
            }
            public Expression_other_functionContext expression_other_function()
            {
                return GetRuleContext<Expression_other_functionContext>(0);
            }
            public LiteralContext literal()
            {
                return GetRuleContext<LiteralContext>(0);
            }
            public Expression_primaryContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_primary; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_primary(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_primaryContext expression_primary()
        {
            Expression_primaryContext _localctx = new Expression_primaryContext(Context, State);
            EnterRule(_localctx, 2, RULE_expression_primary);
            try
            {
                State = 62;
                ErrorHandler.Sync(this);
                switch (TokenStream.LA(1))
                {
                    case TOKEN_OP_LPARENT:
                        EnterOuterAlt(_localctx, 1);
                        {
                            State = 55; Match(TOKEN_OP_LPARENT);
                            State = 56; expression_primary();
                            State = 57; Match(TOKEN_OP_RPARENT);
                        }
                        break;
                    case TOKEN_KEY_NEW:
                        EnterOuterAlt(_localctx, 2);
                        {
                            State = 59; expression_new();
                        }
                        break;
                    case TOKEN_IDENTIFIER:
                        EnterOuterAlt(_localctx, 3);
                        {
                            State = 60; expression_other_function();
                        }
                        break;
                    case TOKEN_KEY_TRUE:
                    case TOKEN_KEY_FALSE:
                    case TOKEN_CONST_STRING:
                    case TOKEN_CONST_INTEGER:
                    case TOKEN_CONST_FLOAT:
                    case TOKEN_CONST_DECIMAL:
                    case TOKEN_CONST_DOUBLE:
                    case TOKEN_CONST_DATE:
                    case TOKEN_CONST_TIME:
                        EnterOuterAlt(_localctx, 4);
                        {
                            State = 61; literal();
                        }
                        break;
                    default:
                        throw new NoViableAltException(this);
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class Expression_newContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_KEY_NEW() { return GetToken(CommonParser.TOKEN_KEY_NEW, 0); }
            public ITerminalNode TOKEN_OP_LBRACE() { return GetToken(CommonParser.TOKEN_OP_LBRACE, 0); }
            public Expression_new_propsContext expression_new_props()
            {
                return GetRuleContext<Expression_new_propsContext>(0);
            }
            public ITerminalNode TOKEN_OP_RBRACE() { return GetToken(CommonParser.TOKEN_OP_RBRACE, 0); }
            public Expression_newContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_new; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_new(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_newContext expression_new()
        {
            Expression_newContext _localctx = new Expression_newContext(Context, State);
            EnterRule(_localctx, 4, RULE_expression_new);
            try
            {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 64; Match(TOKEN_KEY_NEW);
                    State = 65; Match(TOKEN_OP_LBRACE);
                    State = 66; expression_new_props();
                    State = 67; Match(TOKEN_OP_RBRACE);
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class Expression_new_propsContext : ParserRuleContext
        {
            public Expression_assignContext[] expression_assign()
            {
                return GetRuleContexts<Expression_assignContext>();
            }
            public Expression_assignContext expression_assign(int i)
            {
                return GetRuleContext<Expression_assignContext>(i);
            }
            public ITerminalNode[] TOKEN_OP_COMMA() { return GetTokens(CommonParser.TOKEN_OP_COMMA); }
            public ITerminalNode TOKEN_OP_COMMA(int i)
            {
                return GetToken(CommonParser.TOKEN_OP_COMMA, i);
            }
            public Expression_new_propsContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_new_props; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_new_props(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_new_propsContext expression_new_props()
        {
            Expression_new_propsContext _localctx = new Expression_new_propsContext(Context, State);
            EnterRule(_localctx, 6, RULE_expression_new_props);
            int _la;
            try
            {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 69; expression_assign();
                    State = 74;
                    ErrorHandler.Sync(this);
                    _la = TokenStream.LA(1);
                    while (_la == TOKEN_OP_COMMA)
                    {
                        {
                            {
                                State = 70; Match(TOKEN_OP_COMMA);
                                State = 71; expression_assign();
                            }
                        }
                        State = 76;
                        ErrorHandler.Sync(this);
                        _la = TokenStream.LA(1);
                    }
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class Expression_assignContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_IDENTIFIER() { return GetToken(CommonParser.TOKEN_IDENTIFIER, 0); }
            public ITerminalNode TOKEN_OP_EQUAL() { return GetToken(CommonParser.TOKEN_OP_EQUAL, 0); }
            public ExpressionContext expression()
            {
                return GetRuleContext<ExpressionContext>(0);
            }
            public Expression_assignContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_assign; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_assign(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_assignContext expression_assign()
        {
            Expression_assignContext _localctx = new Expression_assignContext(Context, State);
            EnterRule(_localctx, 8, RULE_expression_assign);
            try
            {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 77; Match(TOKEN_IDENTIFIER);
                    State = 78; Match(TOKEN_OP_EQUAL);
                    State = 79; expression(0);
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class Expression_other_functionContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_IDENTIFIER() { return GetToken(CommonParser.TOKEN_IDENTIFIER, 0); }
            public ITerminalNode TOKEN_OP_LPARENT() { return GetToken(CommonParser.TOKEN_OP_LPARENT, 0); }
            public Expression_listContext expression_list()
            {
                return GetRuleContext<Expression_listContext>(0);
            }
            public ITerminalNode TOKEN_OP_RPARENT() { return GetToken(CommonParser.TOKEN_OP_RPARENT, 0); }
            public Expression_other_functionContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_other_function; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_other_function(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_other_functionContext expression_other_function()
        {
            Expression_other_functionContext _localctx = new Expression_other_functionContext(Context, State);
            EnterRule(_localctx, 10, RULE_expression_other_function);
            try
            {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 81; Match(TOKEN_IDENTIFIER);
                    State = 82; Match(TOKEN_OP_LPARENT);
                    State = 83; expression_list();
                    State = 84; Match(TOKEN_OP_RPARENT);
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class Expression_listContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_OP_LPARENT() { return GetToken(CommonParser.TOKEN_OP_LPARENT, 0); }
            public Expression_listContext expression_list()
            {
                return GetRuleContext<Expression_listContext>(0);
            }
            public ITerminalNode TOKEN_OP_RPARENT() { return GetToken(CommonParser.TOKEN_OP_RPARENT, 0); }
            public ExpressionContext[] expression()
            {
                return GetRuleContexts<ExpressionContext>();
            }
            public ExpressionContext expression(int i)
            {
                return GetRuleContext<ExpressionContext>(i);
            }
            public ITerminalNode[] TOKEN_OP_COMMA() { return GetTokens(CommonParser.TOKEN_OP_COMMA); }
            public ITerminalNode TOKEN_OP_COMMA(int i)
            {
                return GetToken(CommonParser.TOKEN_OP_COMMA, i);
            }
            public Expression_listContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_expression_list; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitExpression_list(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public Expression_listContext expression_list()
        {
            Expression_listContext _localctx = new Expression_listContext(Context, State);
            EnterRule(_localctx, 12, RULE_expression_list);
            int _la;
            try
            {
                State = 100;
                ErrorHandler.Sync(this);
                switch (Interpreter.AdaptivePredict(TokenStream, 7, Context))
                {
                    case 1:
                        EnterOuterAlt(_localctx, 1);
                        {
                            State = 86; Match(TOKEN_OP_LPARENT);
                            State = 87; expression_list();
                            State = 88; Match(TOKEN_OP_RPARENT);
                        }
                        break;
                    case 2:
                        EnterOuterAlt(_localctx, 2);
                        {
                            State = 91;
                            ErrorHandler.Sync(this);
                            _la = TokenStream.LA(1);
                            if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TOKEN_OP_LPARENT) | (1L << TOKEN_OP_PLUS) | (1L << TOKEN_OP_DASH) | (1L << TOKEN_OP_BANG) | (1L << TOKEN_KEY_TRUE) | (1L << TOKEN_KEY_FALSE) | (1L << TOKEN_KEY_NEW) | (1L << TOKEN_IDENTIFIER) | (1L << TOKEN_CONST_STRING) | (1L << TOKEN_CONST_INTEGER) | (1L << TOKEN_CONST_FLOAT) | (1L << TOKEN_CONST_DECIMAL) | (1L << TOKEN_CONST_DOUBLE) | (1L << TOKEN_CONST_DATE) | (1L << TOKEN_CONST_TIME))) != 0))
                            {
                                {
                                    State = 90; expression(0);
                                }
                            }

                            State = 97;
                            ErrorHandler.Sync(this);
                            _la = TokenStream.LA(1);
                            while (_la == TOKEN_OP_COMMA)
                            {
                                {
                                    {
                                        State = 93; Match(TOKEN_OP_COMMA);
                                        {
                                            State = 94; expression(0);
                                        }
                                    }
                                }
                                State = 99;
                                ErrorHandler.Sync(this);
                                _la = TokenStream.LA(1);
                            }
                        }
                        break;
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public partial class LiteralContext : ParserRuleContext
        {
            public ITerminalNode TOKEN_CONST_INTEGER() { return GetToken(CommonParser.TOKEN_CONST_INTEGER, 0); }
            public ITerminalNode TOKEN_CONST_FLOAT() { return GetToken(CommonParser.TOKEN_CONST_FLOAT, 0); }
            public ITerminalNode TOKEN_CONST_DECIMAL() { return GetToken(CommonParser.TOKEN_CONST_DECIMAL, 0); }
            public ITerminalNode TOKEN_CONST_DOUBLE() { return GetToken(CommonParser.TOKEN_CONST_DOUBLE, 0); }
            public ITerminalNode TOKEN_CONST_STRING() { return GetToken(CommonParser.TOKEN_CONST_STRING, 0); }
            public ITerminalNode TOKEN_KEY_TRUE() { return GetToken(CommonParser.TOKEN_KEY_TRUE, 0); }
            public ITerminalNode TOKEN_KEY_FALSE() { return GetToken(CommonParser.TOKEN_KEY_FALSE, 0); }
            public ITerminalNode TOKEN_CONST_TIME() { return GetToken(CommonParser.TOKEN_CONST_TIME, 0); }
            public ITerminalNode TOKEN_CONST_DATE() { return GetToken(CommonParser.TOKEN_CONST_DATE, 0); }
            public LiteralContext(ParserRuleContext parent, int invokingState)
                : base(parent, invokingState)
            {
            }
            public override int RuleIndex { get { return RULE_literal; } }
            public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor)
            {
                ICommonParserVisitor<TResult> typedVisitor = visitor as ICommonParserVisitor<TResult>;
                if (typedVisitor != null) return typedVisitor.VisitLiteral(this);
                else return visitor.VisitChildren(this);
            }
        }

        [RuleVersion(0)]
        public LiteralContext literal()
        {
            LiteralContext _localctx = new LiteralContext(Context, State);
            EnterRule(_localctx, 14, RULE_literal);
            int _la;
            try
            {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 102;
                    _la = TokenStream.LA(1);
                    if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TOKEN_KEY_TRUE) | (1L << TOKEN_KEY_FALSE) | (1L << TOKEN_CONST_STRING) | (1L << TOKEN_CONST_INTEGER) | (1L << TOKEN_CONST_FLOAT) | (1L << TOKEN_CONST_DECIMAL) | (1L << TOKEN_CONST_DOUBLE) | (1L << TOKEN_CONST_DATE) | (1L << TOKEN_CONST_TIME))) != 0)))
                    {
                        ErrorHandler.RecoverInline(this);
                    }
                    else
                    {
                        ErrorHandler.ReportMatch(this);
                        Consume();
                    }
                }
            }
            catch (RecognitionException re)
            {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally
            {
                ExitRule();
            }
            return _localctx;
        }

        public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex)
        {
            switch (ruleIndex)
            {
                case 0: return expression_sempred((ExpressionContext)_localctx, predIndex);
            }
            return true;
        }
        private bool expression_sempred(ExpressionContext _localctx, int predIndex)
        {
            switch (predIndex)
            {
                case 0: return Precpred(Context, 9);
                case 1: return Precpred(Context, 8);
                case 2: return Precpred(Context, 7);
                case 3: return Precpred(Context, 6);
                case 4: return Precpred(Context, 5);
                case 5: return Precpred(Context, 4);
            }
            return true;
        }

        private static char[] _serializedATN = {
        '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786',
        '\x5964', '\x3', ')', 'k', '\x4', '\x2', '\t', '\x2', '\x4', '\x3', '\t',
        '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4', '\x6',
        '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b', '\x4',
        '\t', '\t', '\t', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2',
        '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2',
        '\x3', '\x2', '\x3', '\x2', '\x5', '\x2', '\x1E', '\n', '\x2', '\x3',
        '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3',
        '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3',
        '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3',
        '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3',
        '\x2', '\a', '\x2', '\x35', '\n', '\x2', '\f', '\x2', '\xE', '\x2', '\x38',
        '\v', '\x2', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3',
        '\x3', '\x3', '\x3', '\x3', '\x3', '\x5', '\x3', '\x41', '\n', '\x3',
        '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4',
        '\x3', '\x5', '\x3', '\x5', '\x3', '\x5', '\a', '\x5', 'K', '\n', '\x5',
        '\f', '\x5', '\xE', '\x5', 'N', '\v', '\x5', '\x3', '\x6', '\x3', '\x6',
        '\x3', '\x6', '\x3', '\x6', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3',
        '\a', '\x3', '\a', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b',
        '\x3', '\b', '\x5', '\b', '^', '\n', '\b', '\x3', '\b', '\x3', '\b', '\a',
        '\b', '\x62', '\n', '\b', '\f', '\b', '\xE', '\b', '\x65', '\v', '\b',
        '\x5', '\b', 'g', '\n', '\b', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x2',
        '\x3', '\x2', '\n', '\x2', '\x4', '\x6', '\b', '\n', '\f', '\xE', '\x10',
        '\x2', '\a', '\x3', '\x2', '\r', '\xE', '\x4', '\x2', '\xF', '\xF', '\x11',
        '\x12', '\x5', '\x2', '\a', '\n', '\x14', '\x15', '\x18', '\x19', '\x3',
        '\x2', '\v', '\f', '\x4', '\x2', '\x1C', '\x1D', '#', ')', '\x2', 's',
        '\x2', '\x1D', '\x3', '\x2', '\x2', '\x2', '\x4', '@', '\x3', '\x2', '\x2',
        '\x2', '\x6', '\x42', '\x3', '\x2', '\x2', '\x2', '\b', 'G', '\x3', '\x2',
        '\x2', '\x2', '\n', 'O', '\x3', '\x2', '\x2', '\x2', '\f', 'S', '\x3',
        '\x2', '\x2', '\x2', '\xE', '\x66', '\x3', '\x2', '\x2', '\x2', '\x10',
        'h', '\x3', '\x2', '\x2', '\x2', '\x12', '\x13', '\b', '\x2', '\x1', '\x2',
        '\x13', '\x1E', '\x5', '\x4', '\x3', '\x2', '\x14', '\x15', '\a', '\x3',
        '\x2', '\x2', '\x15', '\x16', '\x5', '\x2', '\x2', '\x2', '\x16', '\x17',
        '\a', '\x4', '\x2', '\x2', '\x17', '\x1E', '\x3', '\x2', '\x2', '\x2',
        '\x18', '\x19', '\a', '\x17', '\x2', '\x2', '\x19', '\x1E', '\x5', '\x2',
        '\x2', '\x5', '\x1A', '\x1B', '\t', '\x2', '\x2', '\x2', '\x1B', '\x1E',
        '\x5', '\x2', '\x2', '\x4', '\x1C', '\x1E', '\a', '\x1F', '\x2', '\x2',
        '\x1D', '\x12', '\x3', '\x2', '\x2', '\x2', '\x1D', '\x14', '\x3', '\x2',
        '\x2', '\x2', '\x1D', '\x18', '\x3', '\x2', '\x2', '\x2', '\x1D', '\x1A',
        '\x3', '\x2', '\x2', '\x2', '\x1D', '\x1C', '\x3', '\x2', '\x2', '\x2',
        '\x1E', '\x36', '\x3', '\x2', '\x2', '\x2', '\x1F', ' ', '\f', '\v', '\x2',
        '\x2', ' ', '!', '\a', '\x10', '\x2', '\x2', '!', '\x35', '\x5', '\x2',
        '\x2', '\f', '\"', '#', '\f', '\n', '\x2', '\x2', '#', '$', '\t', '\x3',
        '\x2', '\x2', '$', '\x35', '\x5', '\x2', '\x2', '\v', '%', '&', '\f',
        '\t', '\x2', '\x2', '&', '\'', '\t', '\x2', '\x2', '\x2', '\'', '\x35',
        '\x5', '\x2', '\x2', '\n', '(', ')', '\f', '\b', '\x2', '\x2', ')', '*',
        '\t', '\x4', '\x2', '\x2', '*', '\x35', '\x5', '\x2', '\x2', '\t', '+',
        ',', '\f', '\a', '\x2', '\x2', ',', '-', '\t', '\x5', '\x2', '\x2', '-',
        '\x35', '\x5', '\x2', '\x2', '\b', '.', '/', '\f', '\x6', '\x2', '\x2',
        '/', '\x30', '\a', '\x16', '\x2', '\x2', '\x30', '\x31', '\x5', '\x2',
        '\x2', '\x2', '\x31', '\x32', '\a', '\x1A', '\x2', '\x2', '\x32', '\x33',
        '\x5', '\x2', '\x2', '\a', '\x33', '\x35', '\x3', '\x2', '\x2', '\x2',
        '\x34', '\x1F', '\x3', '\x2', '\x2', '\x2', '\x34', '\"', '\x3', '\x2',
        '\x2', '\x2', '\x34', '%', '\x3', '\x2', '\x2', '\x2', '\x34', '(', '\x3',
        '\x2', '\x2', '\x2', '\x34', '+', '\x3', '\x2', '\x2', '\x2', '\x34',
        '.', '\x3', '\x2', '\x2', '\x2', '\x35', '\x38', '\x3', '\x2', '\x2',
        '\x2', '\x36', '\x34', '\x3', '\x2', '\x2', '\x2', '\x36', '\x37', '\x3',
        '\x2', '\x2', '\x2', '\x37', '\x3', '\x3', '\x2', '\x2', '\x2', '\x38',
        '\x36', '\x3', '\x2', '\x2', '\x2', '\x39', ':', '\a', '\x3', '\x2', '\x2',
        ':', ';', '\x5', '\x4', '\x3', '\x2', ';', '<', '\a', '\x4', '\x2', '\x2',
        '<', '\x41', '\x3', '\x2', '\x2', '\x2', '=', '\x41', '\x5', '\x6', '\x4',
        '\x2', '>', '\x41', '\x5', '\f', '\a', '\x2', '?', '\x41', '\x5', '\x10',
        '\t', '\x2', '@', '\x39', '\x3', '\x2', '\x2', '\x2', '@', '=', '\x3',
        '\x2', '\x2', '\x2', '@', '>', '\x3', '\x2', '\x2', '\x2', '@', '?', '\x3',
        '\x2', '\x2', '\x2', '\x41', '\x5', '\x3', '\x2', '\x2', '\x2', '\x42',
        '\x43', '\a', '\x1E', '\x2', '\x2', '\x43', '\x44', '\a', '\x5', '\x2',
        '\x2', '\x44', '\x45', '\x5', '\b', '\x5', '\x2', '\x45', '\x46', '\a',
        '\x6', '\x2', '\x2', '\x46', '\a', '\x3', '\x2', '\x2', '\x2', 'G', 'L',
        '\x5', '\n', '\x6', '\x2', 'H', 'I', '\a', '\x1B', '\x2', '\x2', 'I',
        'K', '\x5', '\n', '\x6', '\x2', 'J', 'H', '\x3', '\x2', '\x2', '\x2',
        'K', 'N', '\x3', '\x2', '\x2', '\x2', 'L', 'J', '\x3', '\x2', '\x2', '\x2',
        'L', 'M', '\x3', '\x2', '\x2', '\x2', 'M', '\t', '\x3', '\x2', '\x2',
        '\x2', 'N', 'L', '\x3', '\x2', '\x2', '\x2', 'O', 'P', '\a', '\x1F', '\x2',
        '\x2', 'P', 'Q', '\a', '\x13', '\x2', '\x2', 'Q', 'R', '\x5', '\x2', '\x2',
        '\x2', 'R', '\v', '\x3', '\x2', '\x2', '\x2', 'S', 'T', '\a', '\x1F',
        '\x2', '\x2', 'T', 'U', '\a', '\x3', '\x2', '\x2', 'U', 'V', '\x5', '\xE',
        '\b', '\x2', 'V', 'W', '\a', '\x4', '\x2', '\x2', 'W', '\r', '\x3', '\x2',
        '\x2', '\x2', 'X', 'Y', '\a', '\x3', '\x2', '\x2', 'Y', 'Z', '\x5', '\xE',
        '\b', '\x2', 'Z', '[', '\a', '\x4', '\x2', '\x2', '[', 'g', '\x3', '\x2',
        '\x2', '\x2', '\\', '^', '\x5', '\x2', '\x2', '\x2', ']', '\\', '\x3',
        '\x2', '\x2', '\x2', ']', '^', '\x3', '\x2', '\x2', '\x2', '^', '\x63',
        '\x3', '\x2', '\x2', '\x2', '_', '`', '\a', '\x1B', '\x2', '\x2', '`',
        '\x62', '\x5', '\x2', '\x2', '\x2', '\x61', '_', '\x3', '\x2', '\x2',
        '\x2', '\x62', '\x65', '\x3', '\x2', '\x2', '\x2', '\x63', '\x61', '\x3',
        '\x2', '\x2', '\x2', '\x63', '\x64', '\x3', '\x2', '\x2', '\x2', '\x64',
        'g', '\x3', '\x2', '\x2', '\x2', '\x65', '\x63', '\x3', '\x2', '\x2',
        '\x2', '\x66', 'X', '\x3', '\x2', '\x2', '\x2', '\x66', ']', '\x3', '\x2',
        '\x2', '\x2', 'g', '\xF', '\x3', '\x2', '\x2', '\x2', 'h', 'i', '\t',
        '\x6', '\x2', '\x2', 'i', '\x11', '\x3', '\x2', '\x2', '\x2', '\n', '\x1D',
        '\x34', '\x36', '@', 'L', ']', '\x63', '\x66',
    };

        public static readonly ATN _ATN =
            new ATNDeserializer().Deserialize(_serializedATN);


    }
} // namespace Common.Grammar.Antlr
